# 作者；吴同学
# 2024年 12月 30日 08时 08分 39秒
# 1207570802@qq.com

# 下面是难度作业（完成基础作业即可提交）

# 1、把今天讲的元组，字典，字符串，集合，函数缺省参数等所有接口基本功能练习一遍，和上课代码保持一致
def practice():
    tup1 = ('小吴', '小蔡', '小林')
    tup2 = ('20', '21', '22')
    tup3 = ('boy', 'girl', 'girl')

    print(tup1[0])
    print(tup1[0:2])

    tup4 = tup1 + tup2
    print(tup4)

    # del tup3
    # print(tup3)

    print(len(tup1))

    print(max(tup2))

    print(min(tup2))

    dict1 = {'小吴': 18, '小蔡': 17, '小林': 19}

    print(dict1['小吴'])

    dict1['小蔡'] = 18

    print(dict1['小蔡'])

    del dict1['小林']
    print(dict1)

    # del dict1
    # print(dict1)

    print(len(dict1))
    print(str(dict1))

    # dict1.clear()
    #
    # print(dict1)

    if '小吴' in dict1:
        print('Exist')
    else:
        print('Not')

    dict1.pop('小吴')
    print(dict1)

    str1 = 'Sometimes things don\'t work out the way you thought they would.'

    print(str1)
    print(str1[0])
    print(str1[0:5])
    print(str1[0:5] + 'hing')

    if 's' in str1:
        print('Ture')
    else:
        print('False')

    print(str1.capitalize())

    print(str1.count('s', 0))

    set1 = {1, 2, 3, 4}
    set2 = set([4, 5, 6, 7])

    print(set1)
    print(set2)

    set1.add('Hello')
    print(set1)
    set1.update('gaga')
    print(set1)
    set1.remove(1)
    print(set1)
    set1.discard(2)
    print(set1)
    print(len(set2))


# 2、求两个有序数字列表的公共元素


def intersection():
    list1 = [2, 3, 4, 6]
    list2 = [2, 6, 8, 10]
    list3 = list(set(list1).intersection(set(list2)))
    print(list3)

# 3、给定一个n个整型元素的列表a，其中有一个元素出现次数超过n / 2，求这个元素


def seek_num(a):
    count = 0
    candidate = None  # 候选元素做临时变量
    for num in a:
        if count == 0:
            candidate = num
            count = 1
        elif num == candidate:
            count += 1
        else:
            count -= 1
    if a.count(candidate) > len(a) // 2:
        return candidate
    else:
        return None


# 5、将元组 (1,2,3) 和集合 {4,5,6} 合并成一个列表。
def con_tup():
    tup1 = (1, 2, 3)
    tup2 = (4, 5, 6)
    list1 = []
    list1.extend(tup1)
    list1.extend(tup2)
    print(list1)

# 6、在列表 [1,2,3,4,5,6] 首尾分别添加整型元素 7 和 0。


def add_list():
    list1 = [1, 2, 3, 4, 5, 6]
    list1.append(0)
    list1.insert(0, 7)
    print(list1)

# 7、反转列表 [0,1,2,3,4,5,6,7] 。


def list_reverse():
    list1 = [0, 1, 2, 3, 4, 5, 6, 7]
    list1.reverse()
    print(list1)

# 8、反转列表 [0,1,2,3,4,5,6,7] 后给出中元素 5 的索引号。


def list_index():
    lis1 = [0, 1, 2, 3, 4, 5, 6, 7]
    print(lis1.index(5))

# 9、分别统计列表 [True,False,0,1,2] 中 True,False,0,1,2的元素个数，发现了什么？
# 1,0在python中分别与Ture、False等价


def list_statics():
    list1 = [True, False, 0, 1, 2]
    print(list1.count(True))
    print(list1.count(False))
    print(list1.count(0))
    print(list1.count(1))
    print(list1.count(2))


# 10、从列表 [True,1,0,‘x’,None,‘x’,False,2,True] 中删除元素‘x’。
def list_del():
    list1 = [True, 1, 0, 'x', None, 'x', False, 2, True]
    for i in list1:
        if i == 'x':
            list1.remove('x')
    print(list1)


# 11、从列表 [True,1,0,‘x’,None,‘x’,False,2,True] 中删除索引号为4的元素。
def list_index_del():
    list1 = [True, 1, 0, 'x', None, 'x', False, 2, True]
    list1.pop(4)
    print(list1)

# 12、删除列表中索引号为奇数（或偶数）的元素。


def list_del_odd():
    list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    list1 = [x for x in list1 if x % 2 == 0]
    print(list1)

# 13、清空列表中的所有元素。


def list_clear():
    list1 = [1, 2, 3, 4]
    list1.clear()
    print(list1)

# 14、对列表 [3,0,8,5,7] 分别做升序和降序排列。


def list_sort():
    list1 = [3, 0, 8, 5, 7]
    list1.sort()
    print(list1)
    list1.sort(reverse=True)
    print(list1)

# 15、将列表 [3,0,8,5,7] 中大于 5 元素置为1，其余元素置为0。


def list_update():
    list1 = [3, 0, 8, 5, 7]
    list1 = [1 if x > 5 else 0 for x in list1]
    print(list1)

# 16、遍历列表 [‘x’,‘y’,‘z’]，打印每一个元素及其对应的索引号。


def list_print():
    list1 = ['x', 'y', 'z']
    for index in range(len(list1)):
        print(f"{index}, 元素{list1[index]}")

# 17、将列表 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 拆分为奇数组和偶数组两个列表。


def list_split():
    list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    list2 = [x for x in list1 if x % 2 == 0]
    list3 = [x for x in list1 if x % 2 != 0]
    print(list2)
    print('\n')
    print(list3)

# 18、分别根据每一行的首元素和尾元素大小对二维列表 [[6, 5], [3, 7], [2, 8]]
# 排序。相当于按6,3,2进行排序，除非第一个元素相等，按第二个元素排序。


def list_sort_two():
    list1 = [[6, 5], [3, 7], [2, 8]]
    # 使用sorted函数返回一个新列表，并传入lambda函数进行排序
    list1 = sorted(list1, key=lambda x: (x[0], x[0]))
    print(list1)

# 19、从列表 [1,4,7,2,5,8] 索引为3的位置开始，依次插入列表 [‘x’,‘y’,‘z’] 的所有元素。


def list_insert():
    list1 = [1, 4, 7, 2, 5, 8]
    list2 = ['x', 'y', 'z']
    list1[3:3] = list2
    print(list1)
# 20、快速生成由 [5,50) 区间内的整数组成的列表。


def list_printf():
    print(list(range(5, 51)))

# 22、将列表 [‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。


def list_change_tup():
    list1 = ['x', 'y', 'z']
    list2 = [1, 2, 3]
    list3 = list(zip(list1, list2))
    print(list3)

# 23、以列表形式返回字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中所有的键。


def dict_change_list():
    dict1 = {'Alice': 20, 'Beth': 18, 'Cecil': 21}
    list1 = list(dict1.keys())
    print(list1)

# 24、以列表形式返回字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中所有的值。


def dict_change_list_value():
    dict1 = {'Alice': 20, 'Beth': 18, 'Cecil': 21}
    list1 = list(dict1.values())
    print(list1)
# 25、以列表形式返回字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中所有键值对组成的元组。


def dict_change_list_all():
    dict1 = {'Alice': 20, 'Beth': 18, 'Cecil': 21}
    list1 = list(dict1.items())
    print(list1)

# 26、向字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中追加 ‘David’:19
# 键值对，更新Cecil的值为17。


def dict_update():
    dict1 = {'Alice': 20, 'Beth': 18, 'Cecil': 21}
    dict2 = {'David': 19}
    dict1.update(dict2)
    dict1['Cecil'] = 19

    print(dict1)

# 27、删除字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中的Beth键后，清空该字典。


def dict_del():
    dict1 = dict1 = {'Alice': 20, 'Beth': 18, 'Cecil': 21}
    dict1.pop('Beth')
    print(dict1)
    dict1.clear()
    print(dict1)

# 28、判断 David 和 Alice 是否在字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中。


def dict_in():
    dict1 = {'Alice': 20, 'Beth': 18, 'Cecil': 21}
    if 'David' and 'Alice' in dict1:
        return True
    else:
        return False
# 29、遍历字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21}，打印键值对。


def dict_items():
    dict1 = {'Alice': 20, 'Beth': 18, 'Cecil': 21}
    for key, value in dict1.items():
        print(f"{key}: {value}")

# 31、以列表 [‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’] 中的每一个元素为键，默认值都是0，创建一个字典。


def list_change_dict():
    list1 = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
    dict1 = {key: 0 for key in list1}
    print(dict1)
# 32、将二维结构 [[‘a’,1],[‘b’,2]] 和 ((‘x’,3),(‘y’,4)) 转成字典。


def change_dict():
    list1 = [['a', 1], ['b', 2]]
    list2 = (('x', 3), ('y', 4))
    print(dict(list1))
    print(dict(list2))

# 33、将元组 (1,2) 和 (3,4) 合并成一个元组。


def tup_merge():
    tup1 = (1, 2)
    tup2 = (3, 4)
    tup3 = tup1 + tup2
    print(tup3)

# 34、将空间坐标元组 (1,2,3) 的三个元素解包对应到变量 x,y,z。


def tup_change_coo():
    tup1 = (1, 2, 3)
    x, y, z = tup1
    print(f"x = {x}, y = {y}, z = {z}")
# 35、返回元组 (‘Alice’,‘Beth’,‘Cecil’) 中 ‘Cecil’ 元素的索引号。


def tup_index():
    tup1 = ('Alice', 'Beth', 'Cecil')
    index = tup1.index('Cecil')
    print(index)
# 36、返回元组 (2,5,3,2,4) 中元素 2 的个数。


def tup_sum():
    tup1 = (2, 5, 3, 2, 4)
    count = tup1.count(2)
    print(count)
# 37、判断 ‘Cecil’ 是否在元组 (‘Alice’,‘Beth’,‘Cecil’) 中。


def tup_key():
    tup1 = ('Alice', 'Beth', 'Cecil')
    if 'Cecil' in tup1:
        return True
    else:
        return False
# 38、返回在元组 (2,5,3,7) 索引号为2的位置插入元素 9 之后的新元组。


def tup_insert():
    tup1 = (2, 5, 3, 7)
    tup2 = tup1[:2] + (9,) + tup1[2:]
    print(tup2)

# 39、创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。


def creation_set():
    set1 = set()
    set1.add('x')
    set1.add('y')
    set1.add('z')
    print(set1)


# 40、删除集合 {‘x’,‘y’,‘z’} 中的 ‘z’ 元素，增j加元素 ‘w’，然后清空整个集合。
def set_del():
    set1 = {'x', 'y', 'z'}
    set1.remove('z')
    print(set1)
    set1.add('w')
    print(set1)
    set1.clear()
    print(set1)

# 41、返回集合 {‘A’,‘D’,‘B’} 中未出现在集合 {‘D’,‘E’,‘C’} 中的元素（差集）。


def set_diff():
    set1 = {'A', 'D', 'B'}
    set2 = {'D', 'E', 'C'}
    print(set1.difference(set2))
# 42、返回两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 的并集。


def set_union():
    set1 = {'A', 'D', 'B'}
    set2 = {'D', 'E', 'C'}
    print(set1.union(set2))
# 43、返回两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 的交集。


def set_intersection():
    set1 = {'A', 'D', 'B'}
    set2 = {'D', 'E', 'C'}
    set3 = set1.intersection(set2)
    print(set3)
# 44、返回两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 未重复的元素的集合。


def set_sd():
    set1 = {'A', 'D', 'B'}
    set2 = {'D', 'E', 'C'}
    print(set1.symmetric_difference(set2))
# 45、判断两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 是否有重复元素。


def set_isdisjoint():
    set1 = {'A', 'D', 'B'}
    set2 = {'D', 'E', 'C'}
    print(set1.isdisjoint(set2))
# 46、判断集合 {‘A’,‘C’} 是否是集合 {‘D’,‘C’,‘E’,‘A’} 的子集。


def set_issubset():
    set1 = {'A', 'C'}
    set2 = {'D', 'C', 'E', 'A'}
    print(set1.issubset(set2))
# 47、去除数组 [1,2,5,2,3,4,5,‘x’,4,‘x’] 中的重复元素。


def use_dict():
    dict1 = {1, 2, 5, 2, 3, 4, 5, 'x', 4, 'x'}
    list1 = list(set(dict1))
    print(list1)
# 48、返回字符串 ‘abCdEfg’ 的全部大写、全部小写和大下写互换形式。


def str_change():
    str1 = 'abCdEfg'
    print(str1.lower())
    print(str1.upper())
    print(str1.swapcase())
# 49、判断字符串 ‘abCdEfg’ 是否首字母大写，字母是否全部小写，字母是否全部大写。


def str_judge():
    str1 = 'abCdEfg'
    print(str1.istitle())
    print(str1.islower())
    print(str1.isupper())
# 50、返回字符串 ‘this is python’ 首字母大写以及字符串内每个单词首字母大写形式。


def str_title():
    str1 = 'this is python'
    print(str1.capitalize())
    print(str1.title())

# 51、判断字符串 ‘this is python’ 是否以 ‘this’ 开头，又是否以 ‘python’ 结尾。


def str_judge2():
    str1 = 'this is python'
    print(str1.startswith('this'))
    print(str1.endswith('python'))

# 52、返回字符串 ‘this is python’ 中 ‘is’ 的出现次数。


def str_count():
    str1 = 'this is python'
    print(str1.count('is'))
# 53、返回字符串 ‘this is python’ 中 ‘is’ 首次出现和最后一次出现的位置。


def str_find():
    str1 = 'this is python'
    print(str1.find('is'))
    print(str1.rfind('is'))
# 54、将字符串 ‘this is python’ 切片成3个单词。


def str_split():
    str1 = 'this is python'
    print(str1.split(' '))
# 55、返回字符串 ‘blog.csdn.net/xufive/article/details/102946961’ 按路径分隔符切片的结果。


def str_split2():
    str1 = 'blog.csdn.net/xufive/article/details/102946961'
    print(str1.split('/ '))
# 56、将字符串 ‘2.72, 5, 7, 3.14’ 以半角逗号切片后，再将各个元素转成浮点型或整形。


def str_split3():
    str1 = '2.72, 5, 7, 3.14'
    list1 = str1.split(', ')
    list2 = [float(item) if '.' in item else int(item) for item in list1]
    print(type(list2[0]))
    print(type(list2[1]))
    print(type(list2[2]))
    print(type(list2[3]))
    print(list2)

# 57、判断字符串 ‘adS12K56’ 是否完全为字母数字，是否全为数字，是否全为字母？


def str_judge3():
    str1 = 'adS12K56'
    print(str1.isalnum())
    print(str1.isnumeric())
    print(str1.isalpha())
# 58、将字符串 ‘there is python’ 中的 ‘is’ 替换为 ‘are’。


def str_update():
    str1 = 'there is python'
    print(str1.replace('is', 'are'))
# 59、清除字符串 ‘\t python \n’ 左侧、右侧，以及左右两侧的空白字符。


def str_strip():
    str1 = '\t python \n'
    print(str1.strip())

# 60、将三个全英文字符串（比如，‘ok’, ‘hello’, ‘thank you’）分行打印，实现左对齐、右对齐和居中对齐效果。


def str_print():
    str1 = 'ok'
    str2 = 'hello'
    str3 = 'thank you'
    print(str1.ljust(20))
    print(str2.ljust(20))
    print(str3.ljust(20))
    print(str1.center(20))
    print(str2.center(20))
    print(str3.center(20))
    print(str1.rjust(20))
    print(str2.rjust(20))
    print(str3.rjust(20))

# 61、将三个字符串 ‘15’, ‘127’, ‘65535’ 左侧补0成同样长度。


def str_fill():
    str1 = '15'
    str2 = '127'
    str3 = '65535'
    max_len = max(len(str1), len(str2), len(str3))

    print(str1.zfill(max_len))
    print(str2.zfill(max_len))
    print(str3.zfill(max_len))
# 62、将列表 [‘a’,‘b’,‘c’] 中各个元素用’|'连接成一个字符串。


def str_link():
    list1 = ['a', 'b', 'c']
    print('|'.join(list1))
# 63、将字符串 ‘abc’ 相邻的两个字母之间加上半角逗号，生成新的字符串。


def str_new():
    str1 = 'abc'
    print(', '.join(str1))
# 64、从键盘输入手机号码，输出形如 ‘Mobile: 186 6677 7788’ 的字符串。


def str_number():
    while True:
        phone_number = input("请输入手机号码：")
        if phone_number.isdigit() and len(phone_number) == 11:
            number = f"Mobile: {phone_number[:3]} {phone_number[3:7]} {phone_number[7:]}"
            print(number)
            break
        else:
            print("Error！请重新输入！")
# 65、从键盘输入年月日时分秒，输出形如 ‘2019-05-01 12:00:00’ 的字符串。


def get_datetime():
    year = input("请输入年份（例如：2019）：")
    month = input("请输入月份（01-12）：")
    day = input("请输入日期（01-31）：")
    hour = input("请输入小时（00-23）：")
    minute = input("请输入分钟（00-59）：")
    second = input("请输入秒数（00-59）：")

    datetime_str = f"{year}-{month}-{day} {hour}:{minute}:{second}"

    print("输出的时间日期字符串是：", datetime_str)


# 66、给定两个浮点数 3.1415926 和 2.7182818，格式化输出字符串 ‘pi = 3.1416, e = 2.7183’。
def str_format():
    pi = 3.1415926
    e = 2.7182818
    print(f"pi = {pi:.4f}, e = {e:.4f}")
# 67、将 0.00774592 和 356800000 格式化输出为科学计数法字符串。


def format_sci():
    num1 = 0.00774592
    num2 = 356800000

    str1 = f"{num1:.6e}, {num2:.6e}"

    print(str1)
# 68、将列表 [0,1,2,3.14,‘x’,None,’’,list(),{5}] 中各个元素转为布尔型。


def list_bool():
    list1 = [0, 1, 2, 3.14, 'x', None, '', list(), {5}]
    bool_values = list(map(bool, list1))
    print(bool_values)
# 69、返回字符 ‘a’ 和 ‘A’ 的ASCII编码值。


def asc():
    print(ord('a'))
    print(ord('A'))
# 70、返回ASCII编码值为 57 和 122 的字符。


def asc2():
    print(chr(57))
    print(chr(122))
# 71、将列表 [3,‘a’,5.2,4,{},9,[]] 中 大于3的整数或浮点数置为1，其余置为0。


def list_trans():
    list1 = [3, 'a', 5.2, 4, {}, 9, []]
    # isinstance()用于判断两个数是否是x，x数据类型
    temp = [1 if isinstance(x, (int, float)) and x > 3 else 0 for x in list1]
    print(temp)
# 72、将二维列表 [[1], [‘a’,‘b’], [2.3, 4.5, 6.7]] 转为 一维列表。


def change_list():
    list1 = [[1], ['a', 'b'], [2.3, 4.5, 6.7]]

    temp_list = [item for sublist in list1 for item in sublist]

    print(temp_list)
# 73、将等长的键列表和值列表转为字典。


def cov_dict():
    key1 = ['a', 'b', 'c']
    values = [1, 2, 3]
    print(dict(zip(key1, values)))
# 74、数字列表求和。


def sum_list():
    numbers = [1, 2, 3, 4, 5]
    print(sum(numbers))


if __name__ == '__main__':
    # practice()
    # intersection()
    # list1 = [1, 3, 3, 6, 6, 6, 6, 6]
    # print(seek_num(list1))
    # 4、列表、元组，字典的相同点，不同点有哪些，请罗列
    # 都是容器数据结构，可以存储不同类型的数据元素，支持索引访问元素，支持迭代
    # 字典带键值，列表可以修改元素，元组不能修改元素，字典不支持切片操作

    # con_tup()
    # add_list()
    # list_reverse()
    # list_index()
    # list_statics()
    # list_del()
    # list_index_del()
    # list_del_odd()
    # list_clear()
    # list_sort()
    # list_update()
    # list_print()
    # list_split()
    # list_sort_two()
    # list_insert()
    # list_print()

    # 21、若 a = [1,2,3]，令 b = a，执行 b[0] = 9， a[0]亦被改变。为何？如何避免？----讲了深COPY和浅COPY再做
    # 这是浅copy的效果，即拷贝父对象而不会拷贝子对象，如若是深copy则连同子对象一起拷贝，改变一方另一方不变

    # list_change_tup()
    # dict_change_list()
    # dict_change_list_value()
    # dict_change_list_all()
    # dict_update()
    # dict_del()
    # print(dict_in())
    # dict_items()

    # 30、若 a = dict()，令 b = a，执行 b.update({‘x’:1})，
    # a亦被改变。为何？如何避免？----讲了深COPY和浅COPY再做
    # 这是浅copy的效果，即拷贝父对象而不会拷贝子对象，a、b看似是两个独立的字典，实际上指向同一个字典对象，即同一内存位置。
    # 如若是深copy则连同子对象一起拷贝，改变一方另一方不变，可使用copy模块中的deepcopy()方法，或者使用copy()、dict()方法创建字典的副本

    # list_change_dict()
    # change_dict()
    # tup_merge()
    # tup_change_coo()
    # tup_index()
    # tup_sum()
    # print(tup_key())
    # tup_insert()
    # creation_set()
    # set_del()
    # set_diff()
    # set_union()
    # set_intersection()
    # set_sd()
    # set_isdisjoint()
    # set_issubset()
    # use_dict()
    # str_change()
    # str_judge()
    # str_title()
    # str_judge2()
    # str_count()
    # str_find()
    # str_split()
    # str_split2()
    # str_split3()
    # str_judge3()
    # str_update()
    # str_strip()
    # str_print()
    # str_fill()
    # str_link()
    # str_new()
    # str_number()
    # get_datetime()
    # str_format()
    # format_sci()
    # list_bool()
    # asc()
    # asc2()
    # list_trans()
    # change_list()
    # cov_dict()
    sum_list()
